// 版权所有2009年围棋作者。版权所有。
// 此源代码的使用受BSD样式的约束
// 可以在许可证文件中找到的许可证。

// 此文件实现作用域及其包含的对象。

package ast

import (
	"bytes"
	"fmt"
	"go/token"
)

// 作用域维护声明的命名语言实体集
// 在范围内，并链接到紧邻的周围（外部）
// 范围
// None
type Scope struct {
	Outer   *Scope
	Objects map[string]*Object
}

// NewScope创建嵌套在外部范围中的新范围。
func NewScope(outer *Scope) *Scope {
	const n = 4 // 初始范围容量
	return &Scope{outer, make(map[string]*Object, n)}
}

// 查找返回具有给定名称的对象（如果是）
// 在范围s中找到，否则返回nil。外部范围
// 都被忽略了。
// None
func (s *Scope) Lookup(name string) *Object {
	return s.Objects[name]
}

// Insert尝试将命名对象obj插入范围s。
// 如果作用域已包含同名的对象alt，
// Insert保持作用域不变并返回alt。否则
// 它插入obj并返回nil。
// None
func (s *Scope) Insert(obj *Object) (alt *Object) {
	if alt = s.Objects[obj.Name]; alt == nil {
		s.Objects[obj.Name] = obj
	}
	return
}

// 调试支持
func (s *Scope) String() string {
	var buf bytes.Buffer
	fmt.Fprintf(&buf, "scope %p {", s)
	if s != nil && len(s.Objects) > 0 {
		fmt.Fprintln(&buf)
		for _, obj := range s.Objects {
			fmt.Fprintf(&buf, "\t%s %s\n", obj.Kind, obj.Name)
		}
	}
	fmt.Fprintf(&buf, "}\n")
	return buf.String()
}

// ----------------------------------------------------------------------------
// 物体

// 对象描述命名语言实体，如包，
// 常量、类型、变量、函数（包括方法）或标签。
// None
// 数据字段包含特定于对象的数据：
// None
// 种类数据类型数据值
// Pkg*范围包范围
// 各声明的内容物联网
// None
type Object struct {
	Kind ObjKind
	Name string      // 声明名称
	Decl interface{} // 对应字段，XxxSpec，FuncDecl，LabeledStmt，AssignStmt，Scope；还是零
	Data interface{} // 对象特定数据；还是零
	Type interface{} // 类型信息的占位符；可能是零
}

// NewObj创建一个具有给定种类和名称的新对象。
func NewObj(kind ObjKind, name string) *Object {
	return &Object{Kind: kind, Name: name}
}

// Pos计算对象名称声明的源位置。
// 如果无法计算，则结果可能是无效位置
// （obj.Decl可能为零或不正确）。
func (obj *Object) Pos() token.Pos {
	name := obj.Name
	switch d := obj.Decl.(type) {
	case *Field:
		for _, n := range d.Names {
			if n.Name == name {
				return n.Pos()
			}
		}
	case *ImportSpec:
		if d.Name != nil && d.Name.Name == name {
			return d.Name.Pos()
		}
		return d.Path.Pos()
	case *ValueSpec:
		for _, n := range d.Names {
			if n.Name == name {
				return n.Pos()
			}
		}
	case *TypeSpec:
		if d.Name.Name == name {
			return d.Name.Pos()
		}
	case *FuncDecl:
		if d.Name.Name == name {
			return d.Name.Pos()
		}
	case *LabeledStmt:
		if d.Label.Name == name {
			return d.Label.Pos()
		}
	case *AssignStmt:
		for _, x := range d.Lhs {
			if ident, isIdent := x.(*Ident); isIdent && ident.Name == name {
				return ident.Pos()
			}
		}
	case *Scope:
		// 预声明对象-目前无需执行任何操作
	}
	return token.NoPos
}

// ObjKind描述对象所表示的内容。
type ObjKind int

// 可能的对象类型列表。
const (
	Bad ObjKind = iota // 用于错误处理
	Pkg                // 包裹
	Con                // 常数
	Typ                // 类型
	Var                // 变量
	Fun                // 功能或方法
	Lbl                // 标签
)

var objKindStrings = [...]string{
	Bad: "bad",
	Pkg: "package",
	Con: "const",
	Typ: "type",
	Var: "var",
	Fun: "func",
	Lbl: "label",
}

func (kind ObjKind) String() string { return objKindStrings[kind] }
